home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 September / PCWorld_2008-09_cd.bin / domacnost a kancelar / joomla / Joomla_1.5.4-Stable-Full_Package.exe / libraries / phpmailer / phpmailer.php < prev    next >
PHP Script  |  2008-07-06  |  45KB  |  1,501 lines
  1. <?php
  2. ////////////////////////////////////////////////////
  3. // PHPMailer - PHP email class
  4. //
  5. // Class for sending email using either
  6. // sendmail, PHP mail(), or SMTP.  Methods are
  7. // based upon the standard AspEmail(tm) classes.
  8. //
  9. // Copyright (C) 2001 - 2003  Brent R. Matzelle
  10. //
  11. // License: LGPL, see LICENSE
  12. ////////////////////////////////////////////////////
  13.  
  14. /**
  15.  * PHPMailer - PHP email transport class
  16.  * @package PHPMailer
  17.  * @author Brent R. Matzelle
  18.  * @copyright 2001 - 2003 Brent R. Matzelle
  19.  */
  20. class PHPMailer
  21. {
  22.     /////////////////////////////////////////////////
  23.     // PUBLIC VARIABLES
  24.     /////////////////////////////////////////////////
  25.  
  26.     /**
  27.      * Email priority (1 = High, 3 = Normal, 5 = low).
  28.      * @var int
  29.      */
  30.     var $Priority          = 3;
  31.  
  32.     /**
  33.      * Sets the CharSet of the message.
  34.      * @var string
  35.      */
  36.     var $CharSet           = "utf-8";
  37.  
  38.     /**
  39.      * Sets the Content-type of the message.
  40.      * @var string
  41.      */
  42.     var $ContentType        = "text/plain";
  43.  
  44.     /**
  45.      * Sets the Encoding of the message. Options for this are "8bit",
  46.      * "7bit", "binary", "base64", and "quoted-printable".
  47.      * @var string
  48.      */
  49.     var $Encoding          = "8bit";
  50.  
  51.     /**
  52.      * Holds the most recent mailer error message.
  53.      * @var string
  54.      */
  55.     var $ErrorInfo         = "";
  56.  
  57.     /**
  58.      * Sets the From email address for the message.
  59.      * @var string
  60.      */
  61.     var $From               = "root@localhost";
  62.  
  63.     /**
  64.      * Sets the From name of the message.
  65.      * @var string
  66.      */
  67.     var $FromName           = "Root User";
  68.  
  69.     /**
  70.      * Sets the Sender email (Return-Path) of the message.  If not empty,
  71.      * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
  72.      * @var string
  73.      */
  74.     var $Sender            = "";
  75.  
  76.     /**
  77.      * Sets the Subject of the message.
  78.      * @var string
  79.      */
  80.     var $Subject           = "";
  81.  
  82.     /**
  83.      * Sets the Body of the message.  This can be either an HTML or text body.
  84.      * If HTML then run IsHTML(true).
  85.      * @var string
  86.      */
  87.     var $Body               = "";
  88.  
  89.     /**
  90.      * Sets the text-only body of the message.  This automatically sets the
  91.      * email to multipart/alternative.  This body can be read by mail
  92.      * clients that do not have HTML email capability such as mutt. Clients
  93.      * that can read HTML will view the normal Body.
  94.      * @var string
  95.      */
  96.     var $AltBody           = "";
  97.  
  98.     /**
  99.      * Sets word wrapping on the body of the message to a given number of
  100.      * characters.
  101.      * @var int
  102.      */
  103.     var $WordWrap          = 0;
  104.  
  105.     /**
  106.      * Method to send mail: ("mail", "sendmail", or "smtp").
  107.      * @var string
  108.      */
  109.     var $Mailer            = "mail";
  110.  
  111.     /**
  112.      * Sets the path of the sendmail program.
  113.      * @var string
  114.      */
  115.     var $Sendmail          = "/usr/sbin/sendmail";
  116.  
  117.     /**
  118.      * Path to PHPMailer plugins.  This is now only useful if the SMTP class
  119.      * is in a different directory than the PHP include path.
  120.      * @var string
  121.      */
  122.     var $PluginDir         = "";
  123.  
  124.     /**
  125.      *  Holds PHPMailer version.
  126.      *  @var string
  127.      */
  128.     var $Version           = "1.73";
  129.  
  130.     /**
  131.      * Sets the email address that a reading confirmation will be sent.
  132.      * @var string
  133.      */
  134.     var $ConfirmReadingTo  = "";
  135.  
  136.     /**
  137.      *  Sets the hostname to use in Message-Id and Received headers
  138.      *  and as default HELO string. If empty, the value returned
  139.      *  by SERVER_NAME is used or 'localhost.localdomain'.
  140.      *  @var string
  141.      */
  142.     var $Hostname          = "";
  143.  
  144.     /////////////////////////////////////////////////
  145.     // SMTP VARIABLES
  146.     /////////////////////////////////////////////////
  147.  
  148.     /**
  149.      *  Sets the SMTP hosts.  All hosts must be separated by a
  150.      *  semicolon.  You can also specify a different port
  151.      *  for each host by using this format: [hostname:port]
  152.      *  (e.g. "smtp1.example.com:25;smtp2.example.com").
  153.      *  Hosts will be tried in order.
  154.      *  @var string
  155.      */
  156.     var $Host        = "localhost";
  157.  
  158.     /**
  159.      *  Sets the default SMTP server port.
  160.      *  @var int
  161.      */
  162.     var $Port        = 25;
  163.  
  164.     /**
  165.      *  Sets the SMTP HELO of the message (Default is $Hostname).
  166.      *  @var string
  167.      */
  168.     var $Helo        = "";
  169.  
  170.     /**
  171.      *  Sets SMTP authentication. Utilizes the Username and Password variables.
  172.      *  @var bool
  173.      */
  174.     var $SMTPAuth     = false;
  175.  
  176.     /**
  177.      *  Sets SMTP username.
  178.      *  @var string
  179.      */
  180.     var $Username     = "";
  181.  
  182.     /**
  183.      *  Sets SMTP password.
  184.      *  @var string
  185.      */
  186.     var $Password     = "";
  187.  
  188.     /**
  189.      *  Sets the SMTP server timeout in seconds. This function will not
  190.      *  work with the win32 version.
  191.      *  @var int
  192.      */
  193.     var $Timeout      = 10;
  194.  
  195.     /**
  196.      *  Sets SMTP class debugging on or off.
  197.      *  @var bool
  198.      */
  199.     var $SMTPDebug    = false;
  200.  
  201.     /**
  202.      * Prevents the SMTP connection from being closed after each mail
  203.      * sending.  If this is set to true then to close the connection
  204.      * requires an explicit call to SmtpClose().
  205.      * @var bool
  206.      */
  207.     var $SMTPKeepAlive = false;
  208.  
  209.     /**#@+
  210.      * @access private
  211.      */
  212.     var $smtp            = NULL;
  213.     var $to              = array();
  214.     var $cc              = array();
  215.     var $bcc             = array();
  216.     var $ReplyTo         = array();
  217.     var $attachment      = array();
  218.     var $CustomHeader    = array();
  219.     var $message_type    = "";
  220.     var $boundary        = array();
  221.     var $language        = array();
  222.     var $error_count     = 0;
  223.     var $LE              = "\n";
  224.     /**#@-*/
  225.  
  226.     /////////////////////////////////////////////////
  227.     // VARIABLE METHODS
  228.     /////////////////////////////////////////////////
  229.  
  230.     /**
  231.      * Sets message type to HTML.
  232.      * @param bool $bool
  233.      * @return void
  234.      */
  235.     function IsHTML($bool) {
  236.         if($bool == true)
  237.             $this->ContentType = "text/html";
  238.         else
  239.             $this->ContentType = "text/plain";
  240.     }
  241.  
  242.     /**
  243.      * Sets Mailer to send message using SMTP.
  244.      * @return void
  245.      */
  246.     function IsSMTP() {
  247.         $this->Mailer = "smtp";
  248.     }
  249.  
  250.     /**
  251.      * Sets Mailer to send message using PHP mail() function.
  252.      * @return void
  253.      */
  254.     function IsMail() {
  255.         $this->Mailer = "mail";
  256.     }
  257.  
  258.     /**
  259.      * Sets Mailer to send message using the $Sendmail program.
  260.      * @return void
  261.      */
  262.     function IsSendmail() {
  263.         $this->Mailer = "sendmail";
  264.     }
  265.  
  266.     /**
  267.      * Sets Mailer to send message using the qmail MTA.
  268.      * @return void
  269.      */
  270.     function IsQmail() {
  271.         $this->Sendmail = "/var/qmail/bin/sendmail";
  272.         $this->Mailer = "sendmail";
  273.     }
  274.  
  275.  
  276.     /////////////////////////////////////////////////
  277.     // RECIPIENT METHODS
  278.     /////////////////////////////////////////////////
  279.  
  280.     /**
  281.      * Adds a "To" address.
  282.      * @param string $address
  283.      * @param string $name
  284.      * @return void
  285.      */
  286.     function AddAddress($address, $name = "") {
  287.         $cur = count($this->to);
  288.         $this->to[$cur][0] = trim($address);
  289.         $this->to[$cur][1] = $name;
  290.     }
  291.  
  292.     /**
  293.      * Adds a "Cc" address. Note: this function works
  294.      * with the SMTP mailer on win32, not with the "mail"
  295.      * mailer.
  296.      * @param string $address
  297.      * @param string $name
  298.      * @return void
  299.     */
  300.     function AddCC($address, $name = "") {
  301.         $cur = count($this->cc);
  302.         $this->cc[$cur][0] = trim($address);
  303.         $this->cc[$cur][1] = $name;
  304.     }
  305.  
  306.     /**
  307.      * Adds a "Bcc" address. Note: this function works
  308.      * with the SMTP mailer on win32, not with the "mail"
  309.      * mailer.
  310.      * @param string $address
  311.      * @param string $name
  312.      * @return void
  313.      */
  314.     function AddBCC($address, $name = "") {
  315.         $cur = count($this->bcc);
  316.         $this->bcc[$cur][0] = trim($address);
  317.         $this->bcc[$cur][1] = $name;
  318.     }
  319.  
  320.     /**
  321.      * Adds a "Reply-to" address.
  322.      * @param string $address
  323.      * @param string $name
  324.      * @return void
  325.      */
  326.     function AddReplyTo($address, $name = "") {
  327.         $cur = count($this->ReplyTo);
  328.         $this->ReplyTo[$cur][0] = trim($address);
  329.         $this->ReplyTo[$cur][1] = $name;
  330.     }
  331.  
  332.  
  333.     /////////////////////////////////////////////////
  334.     // MAIL SENDING METHODS
  335.     /////////////////////////////////////////////////
  336.  
  337.     /**
  338.      * Creates message and assigns Mailer. If the message is
  339.      * not sent successfully then it returns false.  Use the ErrorInfo
  340.      * variable to view description of the error.
  341.      * @return bool
  342.      */
  343.     function Send() {
  344.         $header = "";
  345.         $body = "";
  346.         $result = true;
  347.  
  348.         if((count($this->to) + count($this->cc) + count($this->bcc)) < 1)
  349.         {
  350.             $this->SetError($this->Lang("provide_address"));
  351.             return false;
  352.         }
  353.  
  354.         // Set whether the message is multipart/alternative
  355.         if(!empty($this->AltBody))
  356.             $this->ContentType = "multipart/alternative";
  357.  
  358.         $this->error_count = 0; // reset errors
  359.         $this->SetMessageType();
  360.         $header .= $this->CreateHeader();
  361.         $body = $this->CreateBody();
  362.  
  363.         if($body == "") { return false; }
  364.  
  365.         // Choose the mailer
  366.         switch($this->Mailer)
  367.         {
  368.             case "sendmail":
  369.                 $result = $this->SendmailSend($header, $body);
  370.                 break;
  371.             case "mail":
  372.                 $result = $this->MailSend($header, $body);
  373.                 break;
  374.             case "smtp":
  375.                 $result = $this->SmtpSend($header, $body);
  376.                 break;
  377.             default:
  378.             $this->SetError($this->Mailer . $this->Lang("mailer_not_supported"));
  379.                 $result = false;
  380.                 break;
  381.         }
  382.  
  383.         return $result;
  384.     }
  385.  
  386.     /**
  387.      * Sends mail using the $Sendmail program.
  388.      * @access private
  389.      * @return bool
  390.      */
  391.     function SendmailSend($header, $body) {
  392.         if ($this->Sender != "") {
  393.             $this->Sender = escapeshellcmd($this->Sender);
  394.             $sendmail = sprintf("%s -oi -f %s -t", $this->Sendmail, $this->Sender);
  395.         } else {
  396.             $sendmail = sprintf("%s -oi -t", $this->Sendmail);
  397.         }
  398.         if(!@$mail = popen($sendmail, "w"))
  399.         {
  400.             $this->SetError($this->Lang("execute") . $this->Sendmail);
  401.             return false;
  402.         }
  403.  
  404.         fputs($mail, $header);
  405.         fputs($mail, $body);
  406.  
  407.         $result = pclose($mail) >> 8 & 0xFF;
  408.         if($result != 0)
  409.         {
  410.             $this->SetError($this->Lang("execute") . $this->Sendmail);
  411.             return false;
  412.         }
  413.  
  414.         return true;
  415.     }
  416.  
  417.     /**
  418.      * Sends mail using the PHP mail() function.
  419.      * @access private
  420.      * @return bool
  421.      */
  422.     function MailSend($header, $body) {
  423.         $to = "";
  424.         for($i = 0; $i < count($this->to); $i++)
  425.         {
  426.             if($i != 0) { $to .= ", "; }
  427.             $to .= $this->to[$i][0];
  428.         }
  429.  
  430.         if ($this->Sender != "" && strlen(ini_get("safe_mode"))< 1)
  431.         {
  432.             $old_from = ini_get("sendmail_from");
  433.             ini_set("sendmail_from", $this->Sender);
  434.             $params = sprintf("-oi -f %s", $this->Sender);
  435.             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body,
  436.                         $header, $params);
  437.         }
  438.         else
  439.             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, $header);
  440.  
  441.         if (isset($old_from))
  442.             ini_set("sendmail_from", $old_from);
  443.  
  444.         if(!$rt)
  445.         {
  446.             $this->SetError($this->Lang("instantiate"));
  447.             return false;
  448.         }
  449.  
  450.         return true;
  451.     }
  452.  
  453.     /**
  454.      * Sends mail via SMTP using PhpSMTP (Author:
  455.      * Chris Ryan).  Returns bool.  Returns false if there is a
  456.      * bad MAIL FROM, RCPT, or DATA input.
  457.      * @access private
  458.      * @return bool
  459.      */
  460.     function SmtpSend($header, $body) {
  461.         include_once($this->PluginDir . "smtp.php");
  462.         $error = "";
  463.         $bad_rcpt = array();
  464.  
  465.         if(!$this->SmtpConnect())
  466.             return false;
  467.  
  468.         $smtp_from = ($this->Sender == "") ? $this->From : $this->Sender;
  469.         if(!$this->smtp->Mail($smtp_from))
  470.         {
  471.             $error = $this->Lang("from_failed") . $smtp_from;
  472.             $this->SetError($error);
  473.             $this->smtp->Reset();
  474.             return false;
  475.         }
  476.  
  477.         // Attempt to send attach all recipients
  478.         for($i = 0; $i < count($this->to); $i++)
  479.         {
  480.             if(!$this->smtp->Recipient($this->to[$i][0]))
  481.                 $bad_rcpt[] = $this->to[$i][0];
  482.         }
  483.         for($i = 0; $i < count($this->cc); $i++)
  484.         {
  485.             if(!$this->smtp->Recipient($this->cc[$i][0]))
  486.                 $bad_rcpt[] = $this->cc[$i][0];
  487.         }
  488.         for($i = 0; $i < count($this->bcc); $i++)
  489.         {
  490.             if(!$this->smtp->Recipient($this->bcc[$i][0]))
  491.                 $bad_rcpt[] = $this->bcc[$i][0];
  492.         }
  493.  
  494.         if(count($bad_rcpt) > 0) // Create error message
  495.         {
  496.             for($i = 0; $i < count($bad_rcpt); $i++)
  497.             {
  498.                 if($i != 0) { $error .= ", "; }
  499.                 $error .= $bad_rcpt[$i];
  500.             }
  501.             $error = $this->Lang("recipients_failed") . $error;
  502.             $this->SetError($error);
  503.             $this->smtp->Reset();
  504.             return false;
  505.         }
  506.  
  507.         if(!$this->smtp->Data($header . $body))
  508.         {
  509.             $this->SetError($this->Lang("data_not_accepted"));
  510.             $this->smtp->Reset();
  511.             return false;
  512.         }
  513.         if($this->SMTPKeepAlive == true)
  514.             $this->smtp->Reset();
  515.         else
  516.             $this->SmtpClose();
  517.  
  518.         return true;
  519.     }
  520.  
  521.     /**
  522.      * Initiates a connection to an SMTP server.  Returns false if the
  523.      * operation failed.
  524.      * @access private
  525.      * @return bool
  526.      */
  527.     function SmtpConnect() {
  528.         if($this->smtp == NULL) { $this->smtp = new SMTP(); }
  529.  
  530.         $this->smtp->do_debug = $this->SMTPDebug;
  531.         $hosts = explode(";", $this->Host);
  532.         $index = 0;
  533.         $connection = ($this->smtp->Connected());
  534.  
  535.         // Retry while there is no connection
  536.         while($index < count($hosts) && $connection == false)
  537.         {
  538.             if(strstr($hosts[$index], ":"))
  539.                 list($host, $port) = explode(":", $hosts[$index]);
  540.             else
  541.             {
  542.                 $host = $hosts[$index];
  543.                 $port = $this->Port;
  544.             }
  545.  
  546.             if($this->smtp->Connect($host, $port, $this->Timeout))
  547.             {
  548.                 if ($this->Helo != '')
  549.                     $this->smtp->Hello($this->Helo);
  550.                 else
  551.                     $this->smtp->Hello($this->ServerHostname());
  552.  
  553.                 if($this->SMTPAuth)
  554.                 {
  555.                     if(!$this->smtp->Authenticate($this->Username,
  556.                                                   $this->Password))
  557.                     {
  558.                         $this->SetError($this->Lang("authenticate"));
  559.                         $this->smtp->Reset();
  560.                         $connection = false;
  561.                     }
  562.                 }
  563.                 $connection = true;
  564.             }
  565.             $index++;
  566.         }
  567.         if(!$connection)
  568.             $this->SetError($this->Lang("connect_host"));
  569.  
  570.         return $connection;
  571.     }
  572.  
  573.     /**
  574.      * Closes the active SMTP session if one exists.
  575.      * @return void
  576.      */
  577.     function SmtpClose() {
  578.         if($this->smtp != NULL)
  579.         {
  580.             if($this->smtp->Connected())
  581.             {
  582.                 $this->smtp->Quit();
  583.                 $this->smtp->Close();
  584.             }
  585.         }
  586.     }
  587.  
  588.     /**
  589.      * Sets the language for all class error messages.  Returns false
  590.      * if it cannot load the language file.  The default language type
  591.      * is English.
  592.      * @param string $lang_type Type of language (e.g. Portuguese: "br")
  593.      * @param string $lang_path Path to the language file directory
  594.      * @access public
  595.      * @return bool
  596.      */
  597.     function SetLanguage($lang_type, $lang_path = "language/") {
  598.         if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php'))
  599.             include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
  600.         else if(file_exists($lang_path.'phpmailer.lang-en.php'))
  601.             include($lang_path.'phpmailer.lang-en.php');
  602.         else
  603.         {
  604.             $this->SetError("Could not load language file");
  605.             return false;
  606.         }
  607.         $this->language = $PHPMAILER_LANG;
  608.  
  609.         return true;
  610.     }
  611.  
  612.     /////////////////////////////////////////////////
  613.     // MESSAGE CREATION METHODS
  614.     /////////////////////////////////////////////////
  615.  
  616.     /**
  617.      * Creates recipient headers.
  618.      * @access private
  619.      * @return string
  620.      */
  621.     function AddrAppend($type, $addr) {
  622.         $addr_str = $type . ": ";
  623.         $addr_str .= $this->AddrFormat($addr[0]);
  624.         if(count($addr) > 1)
  625.         {
  626.             for($i = 1; $i < count($addr); $i++)
  627.                 $addr_str .= ", " . $this->AddrFormat($addr[$i]);
  628.         }
  629.         $addr_str .= $this->LE;
  630.  
  631.         return $addr_str;
  632.     }
  633.  
  634.     /**
  635.      * Formats an address correctly.
  636.      * @access private
  637.      * @return string
  638.      */
  639.     function AddrFormat($addr) {
  640.         if(empty($addr[1]))
  641.             $formatted = $addr[0];
  642.         else
  643.         {
  644.             $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" .
  645.                          $addr[0] . ">";
  646.         }
  647.  
  648.         return $formatted;
  649.     }
  650.  
  651.     /**
  652.      * Wraps message for use with mailers that do not
  653.      * automatically perform wrapping and for quoted-printable.
  654.      * Original written by philippe.
  655.      * @access private
  656.      * @return string
  657.      */
  658.     function WrapText($message, $length, $qp_mode = false) {
  659.         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
  660.  
  661.         $message = $this->FixEOL($message);
  662.         if (substr($message, -1) == $this->LE)
  663.             $message = substr($message, 0, -1);
  664.  
  665.         $line = explode($this->LE, $message);
  666.         $message = "";
  667.         for ($i=0 ;$i < count($line); $i++)
  668.         {
  669.           $line_part = explode(" ", $line[$i]);
  670.           $buf = "";
  671.           for ($e = 0; $e<count($line_part); $e++)
  672.           {
  673.               $word = $line_part[$e];
  674.               if ($qp_mode and (strlen($word) > $length))
  675.               {
  676.                 $space_left = $length - strlen($buf) - 1;
  677.                 if ($e != 0)
  678.                 {
  679.                     if ($space_left > 20)
  680.                     {
  681.                         $len = $space_left;
  682.                         if (substr($word, $len - 1, 1) == "=")
  683.                           $len--;
  684.                         elseif (substr($word, $len - 2, 1) == "=")
  685.                           $len -= 2;
  686.                         $part = substr($word, 0, $len);
  687.                         $word = substr($word, $len);
  688.                         $buf .= " " . $part;
  689.                         $message .= $buf . sprintf("=%s", $this->LE);
  690.                     }
  691.                     else
  692.                     {
  693.                         $message .= $buf . $soft_break;
  694.                     }
  695.                     $buf = "";
  696.                 }
  697.                 while (strlen($word) > 0)
  698.                 {
  699.                     $len = $length;
  700.                     if (substr($word, $len - 1, 1) == "=")
  701.                         $len--;
  702.                     elseif (substr($word, $len - 2, 1) == "=")
  703.                         $len -= 2;
  704.                     $part = substr($word, 0, $len);
  705.                     $word = substr($word, $len);
  706.  
  707.                     if (strlen($word) > 0)
  708.                         $message .= $part . sprintf("=%s", $this->LE);
  709.                     else
  710.                         $buf = $part;
  711.                 }
  712.               }
  713.               else
  714.               {
  715.                 $buf_o = $buf;
  716.                 $buf .= ($e == 0) ? $word : (" " . $word);
  717.  
  718.                 if (strlen($buf) > $length and $buf_o != "")
  719.                 {
  720.                     $message .= $buf_o . $soft_break;
  721.                     $buf = $word;
  722.                 }
  723.               }
  724.           }
  725.           $message .= $buf . $this->LE;
  726.         }
  727.  
  728.         return $message;
  729.     }
  730.  
  731.     /**
  732.      * Set the body wrapping.
  733.      * @access private
  734.      * @return void
  735.      */
  736.     function SetWordWrap() {
  737.         if($this->WordWrap < 1)
  738.             return;
  739.  
  740.         switch($this->message_type)
  741.         {
  742.            case "alt":
  743.               // fall through
  744.            case "alt_attachments":
  745.               $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
  746.               break;
  747.            default:
  748.               $this->Body = $this->WrapText($this->Body, $this->WordWrap);
  749.               break;
  750.         }
  751.     }
  752.  
  753.     /**
  754.      * Assembles message header.
  755.      * @access private
  756.      * @return string
  757.      */
  758.     function CreateHeader() {
  759.         $result = "";
  760.  
  761.         // Set the boundaries
  762.         $uniq_id = md5(uniqid(time()));
  763.         $this->boundary[1] = "b1_" . $uniq_id;
  764.         $this->boundary[2] = "b2_" . $uniq_id;
  765.  
  766.         $result .= $this->HeaderLine("Date", $this->RFCDate());
  767.         if($this->Sender == "")
  768.             $result .= $this->HeaderLine("Return-Path", trim($this->From));
  769.         else
  770.             $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
  771.  
  772.         // To be created automatically by mail()
  773.         if($this->Mailer != "mail")
  774.         {
  775.             if(count($this->to) > 0)
  776.                 $result .= $this->AddrAppend("To", $this->to);
  777.             else if (count($this->cc) == 0)
  778.                 $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
  779.             if(count($this->cc) > 0)
  780.                 $result .= $this->AddrAppend("Cc", $this->cc);
  781.         }
  782.  
  783.         $from = array();
  784.         $from[0][0] = trim($this->From);
  785.         $from[0][1] = $this->FromName;
  786.         $result .= $this->AddrAppend("From", $from);
  787.  
  788.         // sendmail and mail() extract Bcc from the header before sending
  789.         if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->bcc) > 0))
  790.             $result .= $this->AddrAppend("Bcc", $this->bcc);
  791.  
  792.         if(count($this->ReplyTo) > 0)
  793.             $result .= $this->AddrAppend("Reply-to", $this->ReplyTo);
  794.  
  795.         // mail() sets the subject itself
  796.         if($this->Mailer != "mail")
  797.             $result .= $this->HeaderLine("Subject", $this->EncodeHeader(trim($this->Subject)));
  798.  
  799.         $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
  800.         $result .= $this->HeaderLine("X-Priority", $this->Priority);
  801.         $result .= $this->HeaderLine("X-Mailer", "PHPMailer [version " . $this->Version . "]");
  802.  
  803.         if($this->ConfirmReadingTo != "")
  804.         {
  805.             $result .= $this->HeaderLine("Disposition-Notification-To",
  806.                        "<" . trim($this->ConfirmReadingTo) . ">");
  807.         }
  808.  
  809.         // Add custom headers
  810.         for($index = 0; $index < count($this->CustomHeader); $index++)
  811.         {
  812.             $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]),
  813.                        $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
  814.         }
  815.         $result .= $this->HeaderLine("MIME-Version", "1.0");
  816.  
  817.         switch($this->message_type)
  818.         {
  819.             case "plain":
  820.                 $result .= $this->HeaderLine("Content-Transfer-Encoding", $this->Encoding);
  821.                 $result .= sprintf("Content-Type: %s; charset=\"%s\"",
  822.                                     $this->ContentType, $this->CharSet);
  823.                 break;
  824.             case "attachments":
  825.                 // fall through
  826.             case "alt_attachments":
  827.                 if($this->InlineImageExists())
  828.                 {
  829.                     $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s",
  830.                                     "multipart/related", $this->LE, $this->LE,
  831.                                     $this->boundary[1], $this->LE);
  832.                 }
  833.                 else
  834.                 {
  835.                     $result .= $this->HeaderLine("Content-Type", "multipart/mixed;");
  836.                     $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  837.                 }
  838.                 break;
  839.             case "alt":
  840.                 $result .= $this->HeaderLine("Content-Type", "multipart/alternative;");
  841.                 $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  842.                 break;
  843.         }
  844.  
  845.         if($this->Mailer != "mail")
  846.             $result .= $this->LE.$this->LE;
  847.  
  848.         return $result;
  849.     }
  850.  
  851.     /**
  852.      * Assembles the message body.  Returns an empty string on failure.
  853.      * @access private
  854.      * @return string
  855.      */
  856.     function CreateBody() {
  857.         $result = "";
  858.  
  859.         $this->SetWordWrap();
  860.  
  861.         switch($this->message_type)
  862.         {
  863.             case "alt":
  864.                 $result .= $this->GetBoundary($this->boundary[1], "",
  865.                                               "text/plain", "");
  866.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  867.                 $result .= $this->LE.$this->LE;
  868.                 $result .= $this->GetBoundary($this->boundary[1], "",
  869.                                               "text/html", "");
  870.  
  871.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  872.                 $result .= $this->LE.$this->LE;
  873.  
  874.                 $result .= $this->EndBoundary($this->boundary[1]);
  875.                 break;
  876.             case "plain":
  877.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  878.                 break;
  879.             case "attachments":
  880.                 $result .= $this->GetBoundary($this->boundary[1], "", "", "");
  881.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  882.                 $result .= $this->LE;
  883.  
  884.                 $result .= $this->AttachAll();
  885.                 break;
  886.             case "alt_attachments":
  887.                 $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
  888.                 $result .= sprintf("Content-Type: %s;%s" .
  889.                                    "\tboundary=\"%s\"%s",
  890.                                    "multipart/alternative", $this->LE,
  891.                                    $this->boundary[2], $this->LE.$this->LE);
  892.  
  893.                 // Create text body
  894.                 $result .= $this->GetBoundary($this->boundary[2], "",
  895.                                               "text/plain", "") . $this->LE;
  896.  
  897.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  898.                 $result .= $this->LE.$this->LE;
  899.  
  900.                 // Create the HTML body
  901.                 $result .= $this->GetBoundary($this->boundary[2], "",
  902.                                               "text/html", "") . $this->LE;
  903.  
  904.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  905.                 $result .= $this->LE.$this->LE;
  906.  
  907.                 $result .= $this->EndBoundary($this->boundary[2]);
  908.  
  909.                 $result .= $this->AttachAll();
  910.                 break;
  911.         }
  912.         if($this->IsError())
  913.             $result = "";
  914.  
  915.         return $result;
  916.     }
  917.  
  918.     /**
  919.      * Returns the start of a message boundary.
  920.      * @access private
  921.      */
  922.     function GetBoundary($boundary, $charSet, $contentType, $encoding) {
  923.         $result = "";
  924.         if($charSet == "") { $charSet = $this->CharSet; }
  925.         if($contentType == "") { $contentType = $this->ContentType; }
  926.         if($encoding == "") { $encoding = $this->Encoding; }
  927.  
  928.         $result .= $this->TextLine("--" . $boundary);
  929.         $result .= sprintf("Content-Type: %s; charset = \"%s\"",
  930.                             $contentType, $charSet);
  931.         $result .= $this->LE;
  932.         $result .= $this->HeaderLine("Content-Transfer-Encoding", $encoding);
  933.         $result .= $this->LE;
  934.  
  935.         return $result;
  936.     }
  937.  
  938.     /**
  939.      * Returns the end of a message boundary.
  940.      * @access private
  941.      */
  942.     function EndBoundary($boundary) {
  943.         return $this->LE . "--" . $boundary . "--" . $this->LE;
  944.     }
  945.  
  946.     /**
  947.      * Sets the message type.
  948.      * @access private
  949.      * @return void
  950.      */
  951.     function SetMessageType() {
  952.         if(count($this->attachment) < 1 && strlen($this->AltBody) < 1)
  953.             $this->message_type = "plain";
  954.         else
  955.         {
  956.             if(count($this->attachment) > 0)
  957.                 $this->message_type = "attachments";
  958.             if(strlen($this->AltBody) > 0 && count($this->attachment) < 1)
  959.                 $this->message_type = "alt";
  960.             if(strlen($this->AltBody) > 0 && count($this->attachment) > 0)
  961.                 $this->message_type = "alt_attachments";
  962.         }
  963.     }
  964.  
  965.     /**
  966.      * Returns a formatted header line.
  967.      * @access private
  968.      * @return string
  969.      */
  970.     function HeaderLine($name, $value) {
  971.         return $name . ": " . $value . $this->LE;
  972.     }
  973.  
  974.     /**
  975.      * Returns a formatted mail line.
  976.      * @access private
  977.      * @return string
  978.      */
  979.     function TextLine($value) {
  980.         return $value . $this->LE;
  981.     }
  982.  
  983.     /////////////////////////////////////////////////
  984.     // ATTACHMENT METHODS
  985.     /////////////////////////////////////////////////
  986.  
  987.     /**
  988.      * Adds an attachment from a path on the filesystem.
  989.      * Returns false if the file could not be found
  990.      * or accessed.
  991.      * @param string $path Path to the attachment.
  992.      * @param string $name Overrides the attachment name.
  993.      * @param string $encoding File encoding (see $Encoding).
  994.      * @param string $type File extension (MIME) type.
  995.      * @return bool
  996.      */
  997.     function AddAttachment($path, $name = "", $encoding = "base64",
  998.                            $type = "application/octet-stream") {
  999.         if(!@is_file($path))
  1000.         {
  1001.             $this->SetError($this->Lang("file_access") . $path);
  1002.             return false;
  1003.         }
  1004.  
  1005.         $filename = basename($path);
  1006.         if($name == "")
  1007.             $name = $filename;
  1008.  
  1009.         $cur = count($this->attachment);
  1010.         $this->attachment[$cur][0] = $path;
  1011.         $this->attachment[$cur][1] = $filename;
  1012.         $this->attachment[$cur][2] = $name;
  1013.         $this->attachment[$cur][3] = $encoding;
  1014.         $this->attachment[$cur][4] = $type;
  1015.         $this->attachment[$cur][5] = false; // isStringAttachment
  1016.         $this->attachment[$cur][6] = "attachment";
  1017.         $this->attachment[$cur][7] = 0;
  1018.  
  1019.         return true;
  1020.     }
  1021.  
  1022.     /**
  1023.      * Attaches all fs, string, and binary attachments to the message.
  1024.      * Returns an empty string on failure.
  1025.      * @access private
  1026.      * @return string
  1027.      */
  1028.     function AttachAll() {
  1029.         // Return text of body
  1030.         $mime = array();
  1031.  
  1032.         // Add all attachments
  1033.         for($i = 0; $i < count($this->attachment); $i++)
  1034.         {
  1035.             // Check for string attachment
  1036.             $bString = $this->attachment[$i][5];
  1037.             if ($bString)
  1038.                 $string = $this->attachment[$i][0];
  1039.             else
  1040.                 $path = $this->attachment[$i][0];
  1041.  
  1042.             $filename    = $this->attachment[$i][1];
  1043.             $name        = $this->attachment[$i][2];
  1044.             $encoding    = $this->attachment[$i][3];
  1045.             $type        = $this->attachment[$i][4];
  1046.             $disposition = $this->attachment[$i][6];
  1047.             $cid         = $this->attachment[$i][7];
  1048.  
  1049.             $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
  1050.             $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
  1051.             $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
  1052.  
  1053.             if($disposition == "inline")
  1054.                 $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
  1055.  
  1056.             $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s",
  1057.                               $disposition, $name, $this->LE.$this->LE);
  1058.  
  1059.             // Encode as string attachment
  1060.             if($bString)
  1061.             {
  1062.                 $mime[] = $this->EncodeString($string, $encoding);
  1063.                 if($this->IsError()) { return ""; }
  1064.                 $mime[] = $this->LE.$this->LE;
  1065.             }
  1066.             else
  1067.             {
  1068.                 $mime[] = $this->EncodeFile($path, $encoding);
  1069.                 if($this->IsError()) { return ""; }
  1070.                 $mime[] = $this->LE.$this->LE;
  1071.             }
  1072.         }
  1073.  
  1074.         $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
  1075.  
  1076.         return join("", $mime);
  1077.     }
  1078.  
  1079.     /**
  1080.      * Encodes attachment in requested format.  Returns an
  1081.      * empty string on failure.
  1082.      * @access private
  1083.      * @return string
  1084.      */
  1085.     function EncodeFile ($path, $encoding = "base64") {
  1086.         if(!@$fd = fopen($path, "rb"))
  1087.         {
  1088.             $this->SetError($this->Lang("file_open") . $path);
  1089.             return "";
  1090.         }
  1091.         $magic_quotes = get_magic_quotes_runtime();
  1092.         set_magic_quotes_runtime(0);
  1093.         $file_buffer = fread($fd, filesize($path));
  1094.         $file_buffer = $this->EncodeString($file_buffer, $encoding);
  1095.         fclose($fd);
  1096.         set_magic_quotes_runtime($magic_quotes);
  1097.  
  1098.         return $file_buffer;
  1099.     }
  1100.  
  1101.     /**
  1102.      * Encodes string to requested format. Returns an
  1103.      * empty string on failure.
  1104.      * @access private
  1105.      * @return string
  1106.      */
  1107.     function EncodeString ($str, $encoding = "base64") {
  1108.         $encoded = "";
  1109.         switch(strtolower($encoding)) {
  1110.           case "base64":
  1111.               // chunk_split is found in PHP >= 3.0.6
  1112.               $encoded = chunk_split(base64_encode($str), 76, $this->LE);
  1113.               break;
  1114.           case "7bit":
  1115.           case "8bit":
  1116.               $encoded = $this->FixEOL($str);
  1117.               if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1118.                 $encoded .= $this->LE;
  1119.               break;
  1120.           case "binary":
  1121.               $encoded = $str;
  1122.               break;
  1123.           case "quoted-printable":
  1124.               $encoded = $this->EncodeQP($str);
  1125.               break;
  1126.           default:
  1127.               $this->SetError($this->Lang("encoding") . $encoding);
  1128.               break;
  1129.         }
  1130.         return $encoded;
  1131.     }
  1132.  
  1133.     /**
  1134.      * Encode a header string to best of Q, B, quoted or none.
  1135.      * @access private
  1136.      * @return string
  1137.      */
  1138.     function EncodeHeader ($str, $position = 'text') {
  1139.       $x = 0;
  1140.  
  1141.       switch (strtolower($position)) {
  1142.         case 'phrase':
  1143.           if (!preg_match('/[\200-\377]/', $str)) {
  1144.             // Can't use addslashes as we don't know what value has magic_quotes_sybase.
  1145.             $encoded = addcslashes($str, "\0..\37\177\\\"");
  1146.  
  1147.             if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str))
  1148.               return ($encoded);
  1149.             else
  1150.               return ("\"$encoded\"");
  1151.           }
  1152.           $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
  1153.           break;
  1154.         case 'comment':
  1155.           $x = preg_match_all('/[()"]/', $str, $matches);
  1156.           // Fall-through
  1157.         case 'text':
  1158.         default:
  1159.           $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
  1160.           break;
  1161.       }
  1162.  
  1163.       if ($x == 0)
  1164.         return ($str);
  1165.  
  1166.       $maxlen = 75 - 7 - strlen($this->CharSet);
  1167.       // Try to select the encoding which should produce the shortest output
  1168.       if (strlen($str)/3 < $x) {
  1169.         $encoding = 'B';
  1170.         $encoded = base64_encode($str);
  1171.         $maxlen -= $maxlen % 4;
  1172.         $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
  1173.       } else {
  1174.         $encoding = 'Q';
  1175.         $encoded = $this->EncodeQ($str, $position);
  1176.         $encoded = $this->WrapText($encoded, $maxlen, true);
  1177.         $encoded = str_replace("=".$this->LE, "\n", trim($encoded));
  1178.       }
  1179.  
  1180.       $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
  1181.       $encoded = trim(str_replace("\n", $this->LE, $encoded));
  1182.  
  1183.       return $encoded;
  1184.     }
  1185.  
  1186.     /**
  1187.      * Encode string to quoted-printable.
  1188.      * @access private
  1189.      * @return string
  1190.      */
  1191.     function EncodeQP ($str) {
  1192.         $encoded = $this->FixEOL($str);
  1193.         if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1194.             $encoded .= $this->LE;
  1195.  
  1196.         // Replace every high ascii, control and = characters
  1197.         $encoded = preg_replace('/([\000-\010\013\014\016-\037\075\177-\377])/e',
  1198.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1199.         // Replace every spaces and tabs when it's the last character on a line
  1200.         $encoded = preg_replace("/([\011\040])".$this->LE."/e",
  1201.                   "'='.sprintf('%02X', ord('\\1')).'".$this->LE."'", $encoded);
  1202.  
  1203.         // Maximum line length of 76 characters before CRLF (74 + space + '=')
  1204.         $encoded = $this->WrapText($encoded, 74, true);
  1205.  
  1206.         return $encoded;
  1207.     }
  1208.  
  1209.     /**
  1210.      * Encode string to q encoding.
  1211.      * @access private
  1212.      * @return string
  1213.      */
  1214.     function EncodeQ ($str, $position = "text") {
  1215.         // There should not be any EOL in the string
  1216.         $encoded = preg_replace("[\r\n]", "", $str);
  1217.  
  1218.         switch (strtolower($position)) {
  1219.           case "phrase":
  1220.             $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1221.             break;
  1222.           case "comment":
  1223.             $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1224.           case "text":
  1225.           default:
  1226.             // Replace every high ascii, control =, ? and _ characters
  1227.             $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
  1228.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1229.             break;
  1230.         }
  1231.  
  1232.         // Replace every spaces to _ (more readable than =20)
  1233.         $encoded = str_replace(" ", "_", $encoded);
  1234.  
  1235.         return $encoded;
  1236.     }
  1237.  
  1238.     /**
  1239.      * Adds a string or binary attachment (non-filesystem) to the list.
  1240.      * This method can be used to attach ascii or binary data,
  1241.      * such as a BLOB record from a database.
  1242.      * @param string $string String attachment data.
  1243.      * @param string $filename Name of the attachment.
  1244.      * @param string $encoding File encoding (see $Encoding).
  1245.      * @param string $type File extension (MIME) type.
  1246.      * @return void
  1247.      */
  1248.     function AddStringAttachment($string, $filename, $encoding = "base64",
  1249.                                  $type = "application/octet-stream") {
  1250.         // Append to $attachment array
  1251.         $cur = count($this->attachment);
  1252.         $this->attachment[$cur][0] = $string;
  1253.         $this->attachment[$cur][1] = $filename;
  1254.         $this->attachment[$cur][2] = $filename;
  1255.         $this->attachment[$cur][3] = $encoding;
  1256.         $this->attachment[$cur][4] = $type;
  1257.         $this->attachment[$cur][5] = true; // isString
  1258.         $this->attachment[$cur][6] = "attachment";
  1259.         $this->attachment[$cur][7] = 0;
  1260.     }
  1261.  
  1262.     /**
  1263.      * Adds an embedded attachment.  This can include images, sounds, and
  1264.      * just about any other document.  Make sure to set the $type to an
  1265.      * image type.  For JPEG images use "image/jpeg" and for GIF images
  1266.      * use "image/gif".
  1267.      * @param string $path Path to the attachment.
  1268.      * @param string $cid Content ID of the attachment.  Use this to identify
  1269.      *        the Id for accessing the image in an HTML form.
  1270.      * @param string $name Overrides the attachment name.
  1271.      * @param string $encoding File encoding (see $Encoding).
  1272.      * @param string $type File extension (MIME) type.
  1273.      * @return bool
  1274.      */
  1275.     function AddEmbeddedImage($path, $cid, $name = "", $encoding = "base64",
  1276.                               $type = "application/octet-stream") {
  1277.  
  1278.         if(!@is_file($path))
  1279.         {
  1280.             $this->SetError($this->Lang("file_access") . $path);
  1281.             return false;
  1282.         }
  1283.  
  1284.         $filename = basename($path);
  1285.         if($name == "")
  1286.             $name = $filename;
  1287.  
  1288.         // Append to $attachment array
  1289.         $cur = count($this->attachment);
  1290.         $this->attachment[$cur][0] = $path;
  1291.         $this->attachment[$cur][1] = $filename;
  1292.         $this->attachment[$cur][2] = $name;
  1293.         $this->attachment[$cur][3] = $encoding;
  1294.         $this->attachment[$cur][4] = $type;
  1295.         $this->attachment[$cur][5] = false; // isStringAttachment
  1296.         $this->attachment[$cur][6] = "inline";
  1297.         $this->attachment[$cur][7] = $cid;
  1298.  
  1299.         return true;
  1300.     }
  1301.  
  1302.     /**
  1303.      * Returns true if an inline attachment is present.
  1304.      * @access private
  1305.      * @return bool
  1306.      */
  1307.     function InlineImageExists() {
  1308.         $result = false;
  1309.         for($i = 0; $i < count($this->attachment); $i++)
  1310.         {
  1311.             if($this->attachment[$i][6] == "inline")
  1312.             {
  1313.                 $result = true;
  1314.                 break;
  1315.             }
  1316.         }
  1317.  
  1318.         return $result;
  1319.     }
  1320.  
  1321.     /////////////////////////////////////////////////
  1322.     // MESSAGE RESET METHODS
  1323.     /////////////////////////////////////////////////
  1324.  
  1325.     /**
  1326.      * Clears all recipients assigned in the TO array.  Returns void.
  1327.      * @return void
  1328.      */
  1329.     function ClearAddresses() {
  1330.         $this->to = array();
  1331.     }
  1332.  
  1333.     /**
  1334.      * Clears all recipients assigned in the CC array.  Returns void.
  1335.      * @return void
  1336.      */
  1337.     function ClearCCs() {
  1338.         $this->cc = array();
  1339.     }
  1340.  
  1341.     /**
  1342.      * Clears all recipients assigned in the BCC array.  Returns void.
  1343.      * @return void
  1344.      */
  1345.     function ClearBCCs() {
  1346.         $this->bcc = array();
  1347.     }
  1348.  
  1349.     /**
  1350.      * Clears all recipients assigned in the ReplyTo array.  Returns void.
  1351.      * @return void
  1352.      */
  1353.     function ClearReplyTos() {
  1354.         $this->ReplyTo = array();
  1355.     }
  1356.  
  1357.     /**
  1358.      * Clears all recipients assigned in the TO, CC and BCC
  1359.      * array.  Returns void.
  1360.      * @return void
  1361.      */
  1362.     function ClearAllRecipients() {
  1363.         $this->to = array();
  1364.         $this->cc = array();
  1365.         $this->bcc = array();
  1366.     }
  1367.  
  1368.     /**
  1369.      * Clears all previously set filesystem, string, and binary
  1370.      * attachments.  Returns void.
  1371.      * @return void
  1372.      */
  1373.     function ClearAttachments() {
  1374.         $this->attachment = array();
  1375.     }
  1376.  
  1377.     /**
  1378.      * Clears all custom headers.  Returns void.
  1379.      * @return void
  1380.      */
  1381.     function ClearCustomHeaders() {
  1382.         $this->CustomHeader = array();
  1383.     }
  1384.  
  1385.  
  1386.     /////////////////////////////////////////////////
  1387.     // MISCELLANEOUS METHODS
  1388.     /////////////////////////////////////////////////
  1389.  
  1390.     /**
  1391.      * Adds the error message to the error container.
  1392.      * Returns void.
  1393.      * @access private
  1394.      * @return void
  1395.      */
  1396.     function SetError($msg) {
  1397.         $this->error_count++;
  1398.         $this->ErrorInfo = $msg;
  1399.     }
  1400.  
  1401.     /**
  1402.      * Returns the proper RFC 822 formatted date.
  1403.      * @access private
  1404.      * @return string
  1405.      */
  1406.     function RFCDate() {
  1407.         $tz = date("Z");
  1408.         $tzs = ($tz < 0) ? "-" : "+";
  1409.         $tz = abs($tz);
  1410.         $tz = ($tz/3600)*100 + ($tz%3600)/60;
  1411.         $result = sprintf("%s %s%04d", date("D, j M Y H:i:s"), $tzs, $tz);
  1412.  
  1413.         return $result;
  1414.     }
  1415.  
  1416.     /**
  1417.      * Returns the appropriate server variable.  Should work with both
  1418.      * PHP 4.1.0+ as well as older versions.  Returns an empty string
  1419.      * if nothing is found.
  1420.      * @access private
  1421.      * @return mixed
  1422.      */
  1423.     function ServerVar($varName) {
  1424.         global $HTTP_SERVER_VARS;
  1425.         global $HTTP_ENV_VARS;
  1426.  
  1427.         if(!isset($_SERVER))
  1428.         {
  1429.             $_SERVER = $HTTP_SERVER_VARS;
  1430.             if(!isset($_SERVER["REMOTE_ADDR"]))
  1431.                 $_SERVER = $HTTP_ENV_VARS; // must be Apache
  1432.         }
  1433.  
  1434.         if(isset($_SERVER[$varName]))
  1435.             return $_SERVER[$varName];
  1436.         else
  1437.             return "";
  1438.     }
  1439.  
  1440.     /**
  1441.      * Returns the server hostname or 'localhost.localdomain' if unknown.
  1442.      * @access private
  1443.      * @return string
  1444.      */
  1445.     function ServerHostname() {
  1446.         if ($this->Hostname != "")
  1447.             $result = $this->Hostname;
  1448.         elseif ($this->ServerVar('SERVER_NAME') != "")
  1449.             $result = $this->ServerVar('SERVER_NAME');
  1450.         else
  1451.             $result = "localhost.localdomain";
  1452.  
  1453.         return $result;
  1454.     }
  1455.  
  1456.     /**
  1457.      * Returns a message in the appropriate language.
  1458.      * @access private
  1459.      * @return string
  1460.      */
  1461.     function Lang($key) {
  1462.         if(count($this->language) < 1)
  1463.             $this->SetLanguage("en"); // set the default language
  1464.  
  1465.         if(isset($this->language[$key]))
  1466.             return $this->language[$key];
  1467.         else
  1468.             return "Language string failed to load: " . $key;
  1469.     }
  1470.  
  1471.     /**
  1472.      * Returns true if an error occurred.
  1473.      * @return bool
  1474.      */
  1475.     function IsError() {
  1476.         return ($this->error_count > 0);
  1477.     }
  1478.  
  1479.     /**
  1480.      * Changes every end of line from CR or LF to CRLF.
  1481.      * @access private
  1482.      * @return string
  1483.      */
  1484.     function FixEOL($str) {
  1485.         $str = str_replace("\r\n", "\n", $str);
  1486.         $str = str_replace("\r", "\n", $str);
  1487.         $str = str_replace("\n", $this->LE, $str);
  1488.         return $str;
  1489.     }
  1490.  
  1491.     /**
  1492.      * Adds a custom header.
  1493.      * @return void
  1494.      */
  1495.     function AddCustomHeader($custom_header) {
  1496.         $this->CustomHeader[] = explode(":", $custom_header, 2);
  1497.     }
  1498. }
  1499.  
  1500. ?>
  1501.